/**
 * 本地存储工具类
 */
export default {
  /**
   * 判断浏览器是否支持localStorage
   * @returns {boolean} 是否支持localStorage
   */
  isLocalStorageSupported() {
    try {
      const testKey = '__localStorage_test__'
      localStorage.setItem(testKey, testKey)
      localStorage.removeItem(testKey)
      return true
    } catch (e) {
      return false
    }
  },

  /**
   * 判断浏览器是否支持sessionStorage
   * @returns {boolean} 是否支持sessionStorage
   */
  isSessionStorageSupported() {
    try {
      const testKey = '__sessionStorage_test__'
      sessionStorage.setItem(testKey, testKey)
      sessionStorage.removeItem(testKey)
      return true
    } catch (e) {
      return false
    }
  },

  /**
   * 设置localStorage数据
   * @param {string} key - 存储键名
   * @param {*} value - 存储值
   * @returns {boolean} 是否设置成功
   */
  setLocal(key, value) {
    try {
      if (!this.isLocalStorageSupported()) {
        console.warn('浏览器不支持localStorage')
        return false
      }
      
      const jsonValue = JSON.stringify(value)
      localStorage.setItem(key, jsonValue)
      return true
    } catch (error) {
      console.error('localStorage设置失败:', error)
      return false
    }
  },

  /**
   * 获取localStorage数据
   * @param {string} key - 存储键名
   * @param {*} defaultValue - 默认值
   * @returns {*} 存储的数据或默认值
   */
  getLocal(key, defaultValue = null) {
    try {
      if (!this.isLocalStorageSupported()) {
        return defaultValue
      }
      
      const value = localStorage.getItem(key)
      if (value === null) {
        return defaultValue
      }
      
      return JSON.parse(value)
    } catch (error) {
      console.error('localStorage读取失败:', error)
      return defaultValue
    }
  },

  /**
   * 移除localStorage数据
   * @param {string} key - 存储键名
   * @returns {boolean} 是否移除成功
   */
  removeLocal(key) {
    try {
      if (!this.isLocalStorageSupported()) {
        return false
      }
      
      localStorage.removeItem(key)
      return true
    } catch (error) {
      console.error('localStorage移除失败:', error)
      return false
    }
  },

  /**
   * 清空所有localStorage数据
   * @returns {boolean} 是否清空成功
   */
  clearLocal() {
    try {
      if (!this.isLocalStorageSupported()) {
        return false
      }
      
      localStorage.clear()
      return true
    } catch (error) {
      console.error('localStorage清空失败:', error)
      return false
    }
  },

  /**
   * 设置sessionStorage数据
   * @param {string} key - 存储键名
   * @param {*} value - 存储值
   * @returns {boolean} 是否设置成功
   */
  setSession(key, value) {
    try {
      if (!this.isSessionStorageSupported()) {
        console.warn('浏览器不支持sessionStorage')
        return false
      }
      
      const jsonValue = JSON.stringify(value)
      sessionStorage.setItem(key, jsonValue)
      return true
    } catch (error) {
      console.error('sessionStorage设置失败:', error)
      return false
    }
  },

  /**
   * 获取sessionStorage数据
   * @param {string} key - 存储键名
   * @param {*} defaultValue - 默认值
   * @returns {*} 存储的数据或默认值
   */
  getSession(key, defaultValue = null) {
    try {
      if (!this.isSessionStorageSupported()) {
        return defaultValue
      }
      
      const value = sessionStorage.getItem(key)
      if (value === null) {
        return defaultValue
      }
      
      return JSON.parse(value)
    } catch (error) {
      console.error('sessionStorage读取失败:', error)
      return defaultValue
    }
  },

  /**
   * 移除sessionStorage数据
   * @param {string} key - 存储键名
   * @returns {boolean} 是否移除成功
   */
  removeSession(key) {
    try {
      if (!this.isSessionStorageSupported()) {
        return false
      }
      
      sessionStorage.removeItem(key)
      return true
    } catch (error) {
      console.error('sessionStorage移除失败:', error)
      return false
    }
  },

  /**
   * 清空所有sessionStorage数据
   * @returns {boolean} 是否清空成功
   */
  clearSession() {
    try {
      if (!this.isSessionStorageSupported()) {
        return false
      }
      
      sessionStorage.clear()
      return true
    } catch (error) {
      console.error('sessionStorage清空失败:', error)
      return false
    }
  },

  /**
   * 存储带有过期时间的数据
   * @param {string} key - 存储键名
   * @param {*} value - 存储值
   * @param {number} expireMinutes - 过期时间（分钟）
   */
  setWithExpiry(key, value, expireMinutes = 60) {
    const now = new Date()
    const item = {
      value,
      expiry: now.getTime() + expireMinutes * 60 * 1000
    }
    this.setLocal(key, item)
  },

  /**
   * 获取带有过期时间的数据
   * @param {string} key - 存储键名
   * @param {*} defaultValue - 默认值
   * @returns {*} 存储的数据或默认值
   */
  getWithExpiry(key, defaultValue = null) {
    const itemStr = localStorage.getItem(key)
    
    if (!itemStr) {
      return defaultValue
    }
    
    try {
      const item = JSON.parse(itemStr)
      const now = new Date()
      
      // 检查是否过期
      if (now.getTime() > item.expiry) {
        // 数据已过期，删除并返回默认值
        localStorage.removeItem(key)
        return defaultValue
      }
      
      return item.value
    } catch (error) {
      console.error('读取过期数据失败:', error)
      return defaultValue
    }
  }
}

/**
 * 缓存管理工具
 */
export const cacheUtils = {
  /**
   * 设置缓存
   * @param {string} key - 缓存键名
   * @param {*} data - 缓存数据
   * @param {number} ttl - 过期时间（秒），默认300秒（5分钟）
   */
  setCache(key, data, ttl = 300) {
    const cacheData = {
      data,
      timestamp: Date.now(),
      ttl: ttl * 1000
    }
    return storageUtils.setLocal(`cache_${key}`, cacheData)
  },

  /**
   * 获取缓存
   * @param {string} key - 缓存键名
   * @param {*} defaultValue - 默认值
   * @returns {*} 缓存数据或默认值
   */
  getCache(key, defaultValue = null) {
    const cacheData = storageUtils.getLocal(`cache_${key}`)
    
    if (!cacheData) {
      return defaultValue
    }
    
    const { data, timestamp, ttl } = cacheData
    
    // 检查是否过期
    if (Date.now() - timestamp > ttl) {
      // 缓存已过期
      this.removeCache(key)
      return defaultValue
    }
    
    return data
  },

  /**
   * 移除缓存
   * @param {string} key - 缓存键名
   */
  removeCache(key) {
    return storageUtils.removeLocal(`cache_${key}`)
  },

  /**
   * 清空所有缓存
   */
  clearAllCache() {
    const keys = Object.keys(localStorage)
    keys.forEach(key => {
      if (key.startsWith('cache_')) {
        localStorage.removeItem(key)
      }
    })
  }
}

// 导出storageUtils作为默认导出
const storageUtils = {
  isLocalStorageSupported,
  isSessionStorageSupported,
  setLocal,
  getLocal,
  removeLocal,
  clearLocal,
  setSession,
  getSession,
  removeSession,
  clearSession,
  setWithExpiry,
  getWithExpiry
}